Matrices especiales

A = UnitUpperTriangular( [ 1 2 3 ; 1 2 3 ; 1 2 3 ] )

3×3 UnitUpperTriangular{Int64, Matrix{Int64}}:
 1  2  3
 ⋅  1  3
 ⋅  ⋅  1

Más sobre matrices especiales

Más sobre sistemas lineales

Para sistemas “difíciles” o cuando queramos la máxima velocidad, podemos utilizar el paquete LinearSolve.jl

using LinearSolve

A = rand(4, 4)
b = rand(4)
prob = LinearProblem(A, b)
sol = solve(prob)
sol.u

4-element Vector{Float64}:
 -3.64416159092752
  9.087282877480247
 -9.439806345128664
  2.170120487852354

Implementa muchos resolvedores optimizados y tiene, además, un sistema de selección de solvers adecuados.

Video explicativo en Youtube

Distributions.jl

The Distributions package provides a large collection of probabilistic distributions and related functions. Particularly, Distributions implements:

• Sampling from distributions
• Moments (e.g mean, variance, skewness, and kurtosis), entropy, and other properties
• Probability density/mass functions (pdf) and their logarithm (logpdf)
• Moment-generating functions and characteristic functions
• Maximum likelihood estimation
• Distribution composition and derived distributions (Cartesian product of distributions, truncated distributions, censored distributions)

using Random, Distributions
d = Normal()
d + 1.0

Normal{Float64}(μ=1.0, σ=1.0)

@show mean(d)
@show rand(d, 3)

mean(d) = 0.0
rand(d, 3) = [0.4080618199840492, -2.0519555538915393, 1.5910101149355376]

3-element Vector{Float64}:
  0.4080618199840492
 -2.0519555538915393
  1.5910101149355376

x = [0, 0.4, -0.4] 
fit(Normal, x)

Normal{Float64}(μ=0.0, σ=0.32659863237109044)

Ver también MeasureTheory.jl

Turing.jl

Turing is a general-purpose probabilistic programming language for robust, efficient Bayesian inference and decision making. Current features include:

• General-purpose probabilistic programming with an intuitive modelling interface;
• Robust, efficient Hamiltonian Monte Carlo (HMC) sampling for differentiable posterior distributions;
• Particle MCMC sampling for complex posterior distributions involving discrete variables and stochastic control flow; and
• Compositional inference via Gibbs sampling that combines particle MCMC, HMC and random-walk MH (RWMH).

Un ejemplo sencillo

Tutorial básico

Creando animaciones

using Plots 
anim = @animate for n=1:20
    plot( x-> sin(n*x) , label="")
end;

gif(anim, "animation.gif",  fps = 30)

mp4(anim, "video.mp4",  fps = 30)

En un notebook se puede hacer

using Plots
@gif for n=1:20
    plot( x-> sin(n*x) , label="" )
end

Pintando polígonos

x,y =  [0.0, 0.5, 1.0],  [0.0, 1.0, 0.0]
plot(x[[1:end;1]] , y[[1:end; 1]], fill = 0)

Otras librerías de representación

• PyPlot.jl

• Makie.jl

Ecuaciones Diferenciales

Resolución de EDOs

using DifferentialEquations
f(u,p,t) = 1.01*u
u0 = 1/2
tspan = (0.0,1.0)
prob = ODEProblem(f,u0,tspan)
sol = solve(prob, Tsit5(), reltol=1e-8, abstol=1e-8)

using Plots
plot(sol,linewidth=5,title="Solution to the linear ODE with a thick line",
     xaxis="Time (t)",yaxis="u(t) (in μm)",label="My Thick Line!") # legend=false
plot!(sol.t, t->0.5*exp(1.01t),lw=3,ls=:dash,label="True Solution!")

julia implementa por defecto Tsit5 en lugar de Dormund-Prince

ModelingToolkit.jl

ModelingToolkit.jl is a modeling language for high-performance symbolic-numeric computation in scientific computing and scientific machine learning. It then mixes ideas from symbolic computational algebra systems with causal and acausal equation-based modeling frameworks to give an extendable and parallel modeling system. It allows for users to give a high-level description of a model for symbolic preprocessing to analyze and enhance the model. Automatic symbolic transformations, such as index reduction of differential-algebraic equations, make it possible to solve equations that are impossible to solve with a purely numeric-based technique.

ModelingToolkit.jl una capa más sobre DifferentialEquations.jl

using ModelingToolkit, Plots
using ModelingToolkit: t_nounits as t, D_nounits as D

@mtkmodel FOL begin
    @parameters begin
        τ = 3.0 # parameters
    end
    @variables begin
        x(t) = 0.0 # dependent variables
    end
    @equations begin
        D(x) ~ (1 - x) / τ
    end
end

using OrdinaryDiffEq
@mtkbuild fol = FOL()
prob = ODEProblem(fol, [], (0.0, 10.0), [])
sol = solve(prob)

plot(sol)

Vídeo con un ejemplo industrial

JumpProcesses.jl

FeNICS.jl

FEniCS.jl is a wrapper for the FEniCS library for finite element discretizations of PDEs. This wrapper includes three parts:

Installation and direct access to FEniCS via a Conda installation. Alternatively one may use their current FEniCS installation. A low-level development API and provides some functionality to make directly dealing with the library a little bit easier, but still requires knowledge of FEniCS itself. Interfaces have been provided for the main functions and their attributes, and instructions to add further ones can be found here. A high-level API for usage with DifferentialEquations. An example can be seen solving the heat equation with high order adaptive timestepping.

Gridap.jl

Gridap provides a set of tools for the grid-based approximation of partial differential equations (PDEs) written in the Julia programming language. The main motivation behind the development of this library is to provide an easy-to-use framework for the development of complex PDE solvers in a dynamically typed style without sacrificing the performance of statically typed languages. The library currently supports linear and nonlinear PDE systems for scalar and vector fields, single and multi-field problems, conforming and nonconforming finite element discretizations, on structured and unstructured meshes of simplices and hexahedra.

It has a very reach library of worked examples

JuliaFEM.jl

The JuliaFEM project develops open-source software for reliable, scalable, distributed Finite Element Method.

Trixi.jl

Limitaciones y alternativas

Even if your problem is differentiable, if it is unconstrained there is limited benefit (and downsides in the form of more overhead) to using JuMP over tools which are only concerned with function minimization.

Otras opciones

• Optim.jl
• Optimization.jl
• NLopt.jl

Symbolics.jl

using Symbolics
@variables x y

z = x^2 + y

simplify(2x + 2y)

@variables x g(x)
Dt = Differential(x)

Differential(x)

expression = expand_derivatives(Dt(x * g))

expr2 = substitute(expression, Dict([g => x]))

expand_derivatives(expr2)

SymPy.jl

SymPy is a Python library for symbolic mathematics.

This package is a wrapper using PyCall

With the excellent PyCall package of julia, one has access to the many features of the SymPy library from within a Julia session.

It requires Python to run in the background. To install it sometimes it is needed to make a few

using Pkg
Pkg.add("Conda") #  if needed
using Conda
Conda.update()

The only point to this package is that using PyCall to access SymPy is somewhat cumbersome.

Symbolics.jl vs Sympy.jl

Una capa

Denotamos \(\mathbf x = (x_1, \cdots, x_p)\), \(\mathbf y = (y_1, \cdots, y_q)\), \(\mathbf W = (w_{11}, w_{12}, \cdots )\)

Red de neuronas

Hay muchas generalizaciones de esta idea: redes profundas (muchas capas), redes convolucionales, …

¿Cómo de potente es esto? Vídeo de Google DeepMind

Evaluación de la red: forward-propagation

Al algoritmo para, dados los pesos y la entrada calcular la salida se lo llama forward propagation.

Entrenamiento de redes

Se separan los datos en un conjunto de entrenamiento y conjunto de pruebas

Optimización en el entrenamiento

Para optimizar se utilizan múltiples procedimientos.

El ejemplo más sencillo es el descenso por gradiente \[ W_{n+1} = W_n - \gamma \Delta J (W_n). \]

Para calcular \(\nabla J\) se emplea la regla de cadena. A este proceso lo llama back-progation.

Ajustar una línea

Un ejemplo no trivial